home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / wais / waisgate / transprt.c < prev    next >
C/C++ Source or Header  |  1995-05-09  |  12KB  |  472 lines
  1. /* WIDE AREA INFORMATION SERVER SOFTWARE:
  2.    No guarantees or restrictions.  See the readme file for the full standard
  3.    disclaimer.
  4. */
  5.  
  6. #ifndef lint
  7. static char *RCSid = "$Header: /tmp_mnt/net/quake/proj/wais/wais-8-b5/ir/RCS/transprt.c,v 1.2 92/02/12 13:51:34 jonathan Exp $";
  8. #endif
  9.  
  10. /* this is a krufty transport layer for comm mediums that can not handle
  11.  * all 8 bits of ascii.
  12.  * Written by Harry Morris, modified by brewster.
  13.  * Hexcode written by Steve Swartz
  14.  * 
  15.  */
  16.  
  17. /* to do
  18.  *
  19.  *  compression
  20.  *  encryption
  21.  */
  22.  
  23. /* Change log:
  24.  * $Log:    transprt.c,v $
  25.  * Revision 1.2  92/02/12  13:51:34  jonathan
  26.  * Added "$Log" so RCS will put the log message in the header
  27.  * 
  28.  * 
  29.  * 7/7/90 -brewster
  30.  * merged arts and harry's changes 7/7/90 -brewster
  31.  *
  32.  * 11/6/90 -tracy
  33.  * shift 6 bytes starting from [ as IBM gateway program
  34.  * masks out characters [\]^` in input,
  35.  * append H and I to the function names corresponding to the
  36.  * oroginal coding and the modified one. 'I' indicates IBM. 
  37.  */
  38.  
  39. #include "transprt.h"
  40. #include "wmessage.h" 
  41. #include "ustubs.h"
  42.  
  43. /*---------------------------------------------------------------------*/
  44. static char alphaH[] = /* Must be 65 consecutive ascii characters */
  45.   "0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnop";
  46.  
  47.  
  48. /*---------------------------------------------------------------------*/
  49.  
  50. static void hexCodeH _AP((char* data,long* len));
  51.  
  52. static void
  53. hexCodeH(data,len)
  54. char* data;
  55. long* len;
  56. /* compose a message for sending over ascii terminal lines. Input is '*len'
  57.  * binary bytes; output is 'ceiling(*len/3) * 4' characters from alpha[].
  58.  *
  59.  * Encoding goes like this. Let capital letters represent bits:
  60.  * Input bytes:  ABCDEFGH IJKLMNOP QRSTUVWX
  61.  * Output chars: alpha[CDEFGH] alpha[ABIJKL] alpha[QRMNOP] alpha[SRUVWX]
  62.  *
  63.  * 1 byte at end: ABCDEFGH
  64.  * Output chars:  alpha[CDEFGH] alpha[AB0000] alpha[1000000] alpha [1000000]
  65.  *
  66.  * 2 bytes at end: ABCDEFGH IJKLMNOP
  67.  * Output chars:   alpha[CDEFGH] alpha[ABIJKL] alpha[00MNOP] alpha [1000000]
  68.  */
  69. {
  70.   long i, j;
  71.   
  72.   switch (*len % 3)
  73.     {
  74.     case 2:
  75.       i = *len; j = (*len+1)/3 * 4 - 1; *len = j + 1;
  76.       data[j]   = alphaH[64];
  77.       data[j-1] = alphaH[data[i-1] & 0x0f];
  78.       data[j-2] = alphaH[(data[i-2] & 0xc0) >> 2 | (data[i-1] & 0xf0) >> 4];
  79.       data[j-3] = alphaH[data[i-2] & 0x3F];
  80.       break;
  81.     case 1:
  82.       i = *len + 1; j = (*len+2)/3 * 4 - 1; *len = j + 1;
  83.       data[j]   = alphaH[64];
  84.       data[j-1] = alphaH[64];
  85.       data[j-2] = alphaH[(data[i-2] & 0xc0) >> 2];
  86.       data[j-3] = alphaH[data[i-2] & 0x3F];
  87.       break;
  88.     default:
  89.       i = *len + 2; j = (*len)/3 * 4 + 3; *len = j - 3;
  90.       break;
  91.     }
  92.   
  93.   for (i -= 3, j -= 4; i > 0; i -= 3, j -= 4)
  94.     { 
  95.       data[j]   = alphaH[data[i] & 0x3F];
  96.       data[j-1] = alphaH[(data[i] & 0xc0) >> 2 | (data[i-1] & 0x0f)];
  97.       data[j-2] = alphaH[(data[i-2] & 0xc0) >> 2 | (data[i-1] & 0xf0) >> 4];
  98.       data[j-3] = alphaH[data[i-2] & 0x3F];
  99.     }
  100. }
  101.  
  102. /*---------------------------------------------------------------------*/
  103.  
  104. static void hexDecodeH _AP((char* data,long* len));
  105.  
  106. static void
  107. hexDecodeH(data,len)
  108. char* data;
  109. long* len;
  110. /* Incoming data is 'len' letters from alpha[] created by hexCode(). 'len'
  111.  *  will always be divisble by 4. Output is the binary bytes that were 
  112.  *  encoded into 'data'.
  113.  *
  114.  * If alpha[] isn't consecutive ascii characters, then the function moving 
  115.  *  from ascii data to the 'bX' values has to become more complicated than
  116.  *  data[] - alpha[0].
  117.  */
  118. {
  119.   unsigned char b0, b1, b2, b3;
  120.   long i, j;
  121.  
  122.   
  123.   for (i = 3, j = 4; j < *len; i += 3, j += 4)
  124.     {
  125.       b0 = (data[j-4] & 0x07F) - alphaH[0];
  126.       b1 = (data[j-3] & 0x07F) - alphaH[0];
  127.       b2 = (data[j-2] & 0x07F) - alphaH[0];
  128.       b3 = (data[j-1] & 0x07F) - alphaH[0];
  129.       data[i-3] = b0 | (b1 & 0x30) << 2;
  130.       data[i-2] = (b1 & 0x0f) << 4 | (b2 & 0x0f);
  131.       data[i-1] = b3 | (b2 & 0x30) << 2;
  132.     }
  133.  
  134.   *len = *len/4 * 3 - 2;
  135.   b0 = (data[j-4] & 0x07F) - alphaH[0];
  136.   b1 = (data[j-3] & 0x07F) - alphaH[0];
  137.   b2 = (data[j-2] & 0x07F) - alphaH[0];
  138.   b3 = (data[j-1] & 0x07F) - alphaH[0];
  139.   data[i-3] = b0 | (b1 & 0x30) << 2;
  140.  
  141.   if (b2 != 64)    
  142.     {
  143.       data[i-2] = (b1 & 0x0f) << 4 | (b2 & 0x0f);
  144.       (*len)++;
  145.     }
  146.  
  147.   if (b3 != 64)
  148.     {
  149.       data[i-1] = b3 | (b2 & 0x30) << 2;
  150.       (*len)++;
  151.     }
  152. }
  153.  
  154. /*---------------------------------------------------------------------*/
  155.  
  156. void
  157. transportCodeH(data,len)
  158. char* data;
  159. long* len;
  160. /* krufty serial line transport layer - encode in hex and append in cr */
  161. /* Now it also writes a wais packet header on to the front of the packet.
  162.  *   --art 
  163.  */
  164. { 
  165.   hexCodeH(data,len);
  166.   data[*len] = '\r';
  167.   data[*len + 1] = '\0';
  168.   *len += 1;
  169. }
  170.  
  171. /*---------------------------------------------------------------------*/
  172.  
  173. void
  174. transportDecodeH(data,len)
  175. char* data;
  176. long* len;
  177. /* decode above */
  178. /* This does not have to deal with the wais packet header since it has
  179.    been removed at the end of the read.  */
  180. { 
  181.   if (*len == 0)
  182.     return;
  183.     
  184.   *len -= 1;
  185.   hexDecodeH(data,len);
  186. }
  187.  
  188. /*---------------------------------------------------------------------
  189.  Below are the set of transport coding/decoding functions for clients
  190.  dialing through IBM to DowQuest. Unlike the above one that
  191.  uses 65 consecutive ASCII character for the coding/decoding table,
  192.  table entries after charcater 'Z' are shift 6 characters.
  193.  *--------------------------------------------------------------------*/ 
  194.  
  195. #define LAST_NON_SHIFT_CHAR 90
  196. #define SHIFT_OFFSET   6
  197.  
  198. static char alphaI[] = 
  199.   "0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuv";
  200.  
  201.  
  202. static void hexCodeI _AP((char* data,long* len));
  203.  
  204. static void
  205. hexCodeI(data,len)
  206. char* data;
  207. long* len;
  208. /* compose a message for sending over ascii terminal lines. Input is '*len'
  209.  * binary bytes; output is 'ceiling(*len/3) * 4' characters from alpha[].
  210.  *
  211.  * Encoding goes like this. Let capital letters represent bits:
  212.  * Input bytes:  ABCDEFGH IJKLMNOP QRSTUVWX
  213.  * Output chars: alpha[CDEFGH] alpha[ABIJKL] alpha[QRMNOP] alpha[SRUVWX]
  214.  *
  215.  * 1 byte at end: ABCDEFGH
  216.  * Output chars:  alpha[CDEFGH] alpha[AB0000] alpha[1000000] alpha [1000000]
  217.  *
  218.  * 2 bytes at end: ABCDEFGH IJKLMNOP
  219.  * Output chars:   alpha[CDEFGH] alpha[ABIJKL] alpha[00MNOP] alpha [1000000]
  220.  */
  221. {
  222.   long i, j;
  223.   
  224.   switch (*len % 3)
  225.     {
  226.     case 2:
  227.       i = *len; j = (*len+1)/3 * 4 - 1; *len = j + 1;
  228.       data[j]   = alphaI[64];
  229.       data[j-1] = alphaI[data[i-1] & 0x0f];
  230.       data[j-2] = alphaI[(data[i-2] & 0xc0) >> 2 | (data[i-1] & 0xf0) >> 4];
  231.       data[j-3] = alphaI[data[i-2] & 0x3F];
  232.       break;
  233.     case 1:
  234.       i = *len + 1; j = (*len+2)/3 * 4 - 1; *len = j + 1;
  235.       data[j]   = alphaI[64];
  236.       data[j-1] = alphaI[64];
  237.       data[j-2] = alphaI[(data[i-2] & 0xc0) >> 2];
  238.       data[j-3] = alphaI[data[i-2] & 0x3F];
  239.       break;
  240.     default:
  241.       i = *len + 2; j = (*len)/3 * 4 + 3; *len = j - 3;
  242.       break;
  243.     }
  244.   
  245.   for (i -= 3, j -= 4; i > 0; i -= 3, j -= 4)
  246.     { 
  247.       data[j]   = alphaI[data[i] & 0x3F];
  248.       data[j-1] = alphaI[(data[i] & 0xc0) >> 2 | (data[i-1] & 0x0f)];
  249.       data[j-2] = alphaI[(data[i-2] & 0xc0) >> 2 | (data[i-1] & 0xf0) >> 4];
  250.       data[j-3] = alphaI[data[i-2] & 0x3F];
  251.     }
  252. }
  253.  
  254. /*---------------------------------------------------------------------*/
  255.  
  256. static void hexDecodeI _AP((char* data,long * len));
  257.  
  258. static void
  259. hexDecodeI(data,len)
  260. char* data;
  261. long* len;
  262. /* Incoming data is 'len' letters from alpha[] created by hexCode(). 'len'
  263.  *  will always be divisble by 4. Output is the binary bytes that were 
  264.  *  encoded into 'data'.
  265.  *
  266.  * If alpha[] isn't consecutive ascii characters, then the function moving 
  267.  *  from ascii data to the 'bX' values has to become more complicated than
  268.  *  data[] - alpha[0].
  269.  */
  270. {
  271.   unsigned char b0, b1, b2, b3;
  272.   long i, j;
  273.  
  274.   for ( i=0; i < *len ; i++ )
  275.     if ( data[i] > LAST_NON_SHIFT_CHAR ) data[i] -= SHIFT_OFFSET;
  276.   
  277.   for (i = 3, j = 4; j < *len; i += 3, j += 4)
  278.     {
  279.       b0 = (data[j-4] & 0x07F) - alphaI[0];
  280.       b1 = (data[j-3] & 0x07F) - alphaI[0];
  281.       b2 = (data[j-2] & 0x07F) - alphaI[0];
  282.       b3 = (data[j-1] & 0x07F) - alphaI[0];
  283.       data[i-3] = b0 | (b1 & 0x30) << 2;
  284.       data[i-2] = (b1 & 0x0f) << 4 | (b2 & 0x0f);
  285.       data[i-1] = b3 | (b2 & 0x30) << 2;
  286.     }
  287.  
  288.   *len = *len/4 * 3 - 2;
  289.   b0 = (data[j-4] & 0x07F) - alphaI[0];
  290.   b1 = (data[j-3] & 0x07F) - alphaI[0];
  291.   b2 = (data[j-2] & 0x07F) - alphaI[0];
  292.   b3 = (data[j-1] & 0x07F) - alphaI[0];
  293.   data[i-3] = b0 | (b1 & 0x30) << 2;
  294.  
  295.   if (b2 != 64)    
  296.     {
  297.       data[i-2] = (b1 & 0x0f) << 4 | (b2 & 0x0f);
  298.       (*len)++;
  299.     }
  300.  
  301.   if (b3 != 64)
  302.     {
  303.       data[i-1] = b3 | (b2 & 0x30) << 2;
  304.       (*len)++;
  305.     }
  306. }
  307.  
  308. /*---------------------------------------------------------------------*/
  309.  
  310. void
  311. transportCodeI(data,len)
  312. char* data;
  313. long* len;
  314. /* krufty serial line transport layer - encode in hex and append in cr */
  315. /* Now it also writes a wais packet header on to the front of the packet.
  316.  *   --art 
  317.  */
  318. { 
  319.   hexCodeI(data,len);
  320.   data[*len] = '\r';
  321.   data[*len + 1] = '\0';
  322.   *len += 1;
  323. }
  324.  
  325. /*---------------------------------------------------------------------*/
  326.  
  327. void
  328. transportDecodeI(data,len)
  329. char* data;
  330. long* len;
  331. /* decode above */
  332. /* This does not have to deal with the wais packet header since it has
  333.    been removed at the end of the read.  */
  334. { 
  335.   if (*len == 0)
  336.     return;
  337.     
  338.   *len -= 1;
  339.   hexDecodeI(data,len);
  340. }
  341.  
  342. /*---------------------------------------------------------------------*/
  343.  
  344.  
  345. #ifdef NOTDEFINED /* here for back compatibility */
  346.  
  347. static void hexCode _AP((char* data,long * len));
  348.  
  349. static void
  350. hexCode(data,len)
  351. char* data;
  352. long* len;
  353. /* compose a message for sending over ascii terminal lines.  The data is hex,
  354.  */
  355. { long i;
  356.   for (i = *len-1; i >= 0; i--)
  357.     { data[i*2+1] = (data[i]&0x0F) + 'a';
  358.       data[i*2] = ((data[i]>>4)&0x0F) + 'a';
  359.     }
  360.   data[*len*2] = '\0';
  361.   *len = *len * 2;
  362. }
  363.  
  364. /*---------------------------------------------------------------------------*/
  365.  
  366. static void hexDecode _AP((char* data,long * len));
  367.  
  368. static void
  369. hexDecode(data,len)
  370. char* data;
  371. long* len;
  372. /* converts a buffer full of dataLen bytes of hex in place into the
  373. equivalent binary form. len is filled with the actual number of binary bytes.
  374.  */
  375. { long i;
  376.   *len = *len / 2;
  377.   for (i = 0; i < *len; i++)
  378.     { long temp = 0;
  379.       temp = (data[i*2]-'a')<<4;
  380.       temp += data[i*2+1]-'a';
  381.       data[i] = (char)temp;
  382.     }
  383.   data[*len] = '\0';
  384. }
  385.  
  386. #endif /* def NOTDEFINED */
  387. /*---------------------------------------------------------------------------*/
  388.  
  389. boolean
  390. transportCode(encoding,data,len)
  391. long encoding;
  392. char* data;
  393. long* len;
  394. /* krufty serial line transport layer - encode in hex and add trailing nl */
  395. {
  396.   switch (encoding){
  397.   case NO_ENCODING:
  398.     /* do nothing */
  399.     return(true);
  400.   case HEX_ENCODING:
  401.     transportCodeH(data,len);
  402.     return(true);
  403.   case IBM_HEXCODING:
  404.     transportCodeI(data,len);
  405.     return(true);
  406.   default:
  407.     return(false);
  408.   }
  409. }
  410.  
  411. /*---------------------------------------------------------------------------*/
  412.  
  413. boolean
  414. transportDecode(encoding,data,len)
  415. long encoding;
  416. char* data;
  417. long* len;
  418. /* decode above */
  419. {
  420.   switch (encoding){
  421.   case NO_ENCODING:
  422.     /* do nothing */
  423.     return(true);
  424.   case HEX_ENCODING:
  425.     transportDecodeH(data,len);
  426.     return(true);
  427.   case IBM_HEXCODING:
  428.     transportDecodeI(data,len);
  429.     return(true);
  430.   default:
  431.     return(false);
  432.   }
  433. }
  434.  
  435. /*---------------------------------------------------------------------------*/
  436.  
  437.  
  438.  
  439.  
  440.  
  441.  
  442. #ifdef old /* from the bad old days */
  443.  
  444.  
  445. /*---------------------------------------------------------------------------*/
  446.  
  447. void
  448. transportCode(data,len)
  449. char* data;
  450. long* len;
  451. /* krufty serial line transport layer - encode in hex and add trailing nl */
  452. {
  453.   hexCode(data,len);
  454.   data[*len] = '\r';
  455.   data[*len+1] = '\0';
  456. }
  457.  
  458. /*---------------------------------------------------------------------------*/
  459.  
  460. void
  461. transportDecode(data,len)
  462. char* data;
  463. long* len;
  464. /* decode above */
  465. {
  466.   hexDecode(data,len);
  467. }
  468.  
  469. /*---------------------------------------------------------------------------*/
  470.  
  471. #endif /* old */
  472.